Partial solution for #7 -- implementation of yieldAll and recursive generators through SpecSharp nested iterators.

Considerations:

• Needs performance measurement against original implementation (and, probably, extraction into separate API if this turns out to be considerably slower)

• Increased allocation overhead by one object per iterator: RootIterator is allocated when iterating over the generated sequence (negligible?)

• Probably some optimizations are possible that simplify the iterator behavior in cases when there were no yieldAll calls up to some point

• Tail recursion can be optimized, but not in a transparent way. One option is to add separate function generateWithTail (or something) that would take a coroutine returning Sequence<T>

  fun fromTo(from: Int, to: Int): Sequence<Int> = generateWithTail f@{
     if (from > to) return@f emptySequence()
     yield(from)
     return@f fromTo(from + 1, to)
  }
  

  Another option is to request a coroutines API that would allow one to find out that a Continuation<Unit> is basically a NOP that will do nothing but immediately finish the coroutine block. Once we know this about continuations we can easily optimize tail recursion.